home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / µSim 1.0.5 / source / DoEditDialog.c < prev    next >
Encoding:
Text File  |  1995-04-09  |  6.2 KB  |  240 lines  |  [TEXT/CWIE]
  1. /*
  2. Copyright © 1993,1994,1995 Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware:
  5. you may copy, exchange, modify this code.
  6. You may include this code in any kind of application: freeware,
  7. shareware, or commercial, provided that full credits are given.
  8. You may not sell or distribute this code for profit.
  9. */
  10.  
  11. //#pragma load "MacDump"
  12.  
  13. #include    "UtilsSys7.h"
  14. #include    "Globals.h"
  15. #include    "Animation.h"
  16. #include    "DoEditDialog.h"
  17. #include    "DoMenu.h"
  18. #include    "Main.h"
  19. #include    "MovableModal.h"
  20. #include    "Registers.h"
  21. #include    "SimUtils.h"
  22. #include    "Independents.h"
  23. #include    "Conversions.h"
  24.  
  25. #if defined(FabSystem7orlater)
  26.  
  27. #pragma segment Rare
  28.  
  29. static short EditValue(ConstStr255Param str0, ConstStr255Param str1, short edit, short base);
  30. static void EditUserProc(DialogPtr myDPtr, Handle itemHandle, short itemHit);
  31. static Boolean EditNumPreProcessKey(EventRecord *thEv, DialogPtr theD);
  32.  
  33. static short    lastChoice;
  34.  
  35. //static pascal Boolean EditNumFilter(DialogPtr, EventRecord *, short *);
  36.  
  37. /* DoEditDump: we shall edit a memory location */
  38.  
  39. Boolean DoEditDump(short *addr, short wordn)
  40. {
  41. Str27    tempStr0;
  42. Str15    tempStr1;
  43. register short    newv;
  44. register Boolean changed;
  45.  
  46. GetIndHString((StringPtr)&tempStr0, Get1Resource('STR#', kValueFollow), kAtMem);
  47. ShortToHexString(wordn, tempStr1);
  48. newv = EditValue(tempStr0, tempStr1, *addr, kPOP_HEX);
  49. if (changed = (newv != *addr))
  50.     *addr = newv;
  51. return changed;
  52. }
  53.  
  54. /* DoEditDialog: we shall edit a register or an internal processor part */
  55.  
  56. Boolean DoEditDialog(short item, short pclass, short base)
  57. {
  58. Str27    tempStr0;
  59. Str31    tempStr1;
  60. register short *oldv;
  61. register short    newv;
  62. register Boolean changed;
  63.  
  64. GetIndHString((StringPtr)&tempStr0, Get1Resource('STR#', kValueFollow), kInThe);
  65. GetIndHString((StringPtr)&tempStr1, Get1Resource('STR#', pclass), item);
  66. oldv = pclass == kPART_NAMES ? &gParts[item] : &gRegs[item];
  67. newv = EditValue(tempStr0, tempStr1, *oldv, base);
  68. if (changed = (newv != *oldv)) {
  69.     *oldv = newv;
  70.     if (pclass == kPART_NAMES)
  71.         ChangedBox(item);
  72.     }
  73. return changed;
  74. }
  75.  
  76. enum {
  77. kItemEditValue = 3,
  78. kItemPopupBase
  79. };
  80.  
  81. static short EditValue(ConstStr255Param str0, ConstStr255Param str1, short edit, short base)
  82. {
  83.  
  84. enum {
  85. kDLOG_EDITVALUE = 261
  86. };
  87.  
  88. Str255    EditStr;
  89. long    tempLong;
  90.  
  91. dialogItems    things[] = {{ ok, 0, 1L },
  92.                         { cancel, 0, 0L },
  93.                         { kItemEditValue, 0, 0L },
  94.                         { kItemPopupBase, 0, 0L },
  95.                         { 0, 0, 0L}
  96.                         };
  97.  
  98. things[kItemEditValue-1].refCon = (long)&EditStr;
  99. things[kItemPopupBase-1].refCon = base;
  100. tempLong = edit;
  101. lastChoice = base;
  102. ParamText(str0, str1, nil, nil);
  103. FromNumToString(EditStr, edit, base);
  104. //things[kItemEditValue-1].refCon = ;
  105.  
  106. if (HandleMovableModalDialog(things, gPrefs.remembWind ? &gPrefs.editValueTL : nil, nil, nil, nil, nil, EditUserProc,
  107.     AdjustMenus,
  108.     Handle_My_Menu,
  109.     DomyKeyEvent,
  110.     EditNumPreProcessKey,
  111.     nil,
  112.     DoUpdate,
  113.     DoActivate,
  114.     DoHighLevelEvent,
  115.     DoOSEvent,
  116.     DoIdle,
  117.     ULONG_MAX,
  118.     kDLOG_EDITVALUE) == ok) {
  119.     tempLong = 0L;
  120.     FromStringToNum((ConstStr255Param)&EditStr, &tempLong, lastChoice);
  121.     }
  122. return tempLong;
  123. }
  124.  
  125. void EditUserProc(DialogPtr myDPtr, Handle itemHandle, short itemHit)
  126. {
  127. Str255    tempStr;
  128. Rect    tempRect;
  129. Handle    tempH;
  130. long    tempnum;
  131. short    null;
  132. register short    newChoice;
  133.  
  134. if (itemHit == kItemPopupBase)
  135.     if ((newChoice = GetControlValue((ControlHandle)itemHandle)) != lastChoice) {
  136.         GetDialogItem(myDPtr, kItemEditValue, &null, &tempH, &tempRect);
  137.         GetDialogItemText(tempH, tempStr);
  138.         tempnum = 0L;
  139.         FromStringToNum((ConstStr255Param)&tempStr, &tempnum, lastChoice);
  140.         FromNumToString(tempStr, (short)tempnum, newChoice);
  141.         lastChoice = newChoice;
  142.         SetDialogItemText(tempH, tempStr);
  143.         SelectDialogItemText(myDPtr, kItemEditValue, 0, 0x7FFF);
  144.         }
  145. }
  146.  
  147. Boolean EditNumPreProcessKey(EventRecord *thEv, DialogPtr theD)
  148. {
  149. short    iHit;
  150. unsigned char    keypressed;
  151. Boolean    result = true;
  152.  
  153. keypressed = CHARFROMMESSAGE(thEv->message);
  154. if (lastChoice != kPOP_TEXT) {
  155.     if ((keypressed >= 'a') && (keypressed <= 'z')) {
  156.         keypressed -= 'a' - 'A';    /* cambiare! */
  157.         CHARFROMMESSAGE(thEv->message) = keypressed;
  158.         }
  159.     iHit = ((DialogPeek)theD)->editField + 1;
  160.     if (keypressed >= 32 && ((thEv->modifiers & cmdKey) == 0)) {
  161.         switch( lastChoice ) {
  162.             case kPOP_DEC:    return( Munger((Handle)GetString(kSTR_DECALLOWED), 1L,
  163.                                     &keypressed, 1L, 0L, 0L) >= 0L );
  164.                             break;
  165.             case kPOP_HEX:    return( Munger((Handle)GetString(kSTR_HEXALLOWED), 1L,
  166.                                     &keypressed, 1L, 0L, 0L) >= 0L );
  167.                             break;
  168.             case kPOP_OCT:    return( Munger((Handle)GetString(kSTR_OCTALLOWED), 1L,
  169.                                     &keypressed, 1L, 0L, 0L) >= 0L );
  170.                             break;
  171.             case kPOP_BIN:    return( Munger((Handle)GetString(kSTR_BINALLOWED), 1L,
  172.                                     &keypressed, 1L, 0L, 0L) >= 0L );
  173.                             break;
  174.             }
  175.         }
  176.     }
  177. return result;
  178. }
  179.  
  180. /* EditNumFilter: the filter filters entered characters, of course */
  181. /*
  182. static pascal Boolean EditNumFilter(DialogPtr theD, EventRecord *thEv, short *iHit)
  183. {
  184. GrafPtr    savePort;
  185. unsigned char    keypressed;
  186. register Boolean    retVal;
  187.  
  188. switch(thEv->what) {
  189.     case keyDown    :
  190.     case autoKey    :
  191.         keypressed = CHARFROMMESSAGE(thEv->message);
  192.         if (lastChoice != kPOP_TEXT) {
  193.             if ((keypressed >= 'a') && (keypressed <= 'z')) {
  194.                 keypressed -= 'a' - 'A';
  195.                 CHARFROMMESSAGE(thEv->message) = keypressed;
  196.                 }
  197.             if ((keypressed >= 32) && (keypressed != 0x7F) && ((thEv->modifiers & cmdKey) == 0)) {
  198.                 *iHit = kItemEditValue;
  199.                 switch( lastChoice ) {
  200.                     case kPOP_DEC:    return( Munger((Handle)GetString(kSTR_DECALLOWED), 1L,
  201.                                             &keypressed, 1L, 0L, 0L) < 0L );
  202.                                     break;
  203.                     case kPOP_HEX:    return( Munger((Handle)GetString(kSTR_HEXALLOWED), 1L,
  204.                                             &keypressed, 1L, 0L, 0L) < 0L );
  205.                                     break;
  206.                     case kPOP_OCT:    return( Munger((Handle)GetString(kSTR_OCTALLOWED), 1L,
  207.                                             &keypressed, 1L, 0L, 0L) < 0L );
  208.                                     break;
  209.                     case kPOP_BIN:    return( Munger((Handle)GetString(kSTR_BINALLOWED), 1L,
  210.                                             &keypressed, 1L, 0L, 0L) < 0L );
  211.                                     break;
  212.                     }
  213.                 }
  214.             }
  215.         break;
  216.     case updateEvt:
  217.         if (theD != (DialogPtr)thEv->message) {
  218.             DoUpdate(thEv);
  219.             *iHit = kfakeUpdateItem;
  220.             return true;
  221.             }
  222.         break;
  223.     case activateEvt:
  224.         if (theD != (DialogPtr)thEv->message) {
  225.             DoActivate(thEv);
  226.             *iHit = kfakeUpdateItem;
  227.             return true;
  228.             }
  229.         break;
  230.     }
  231. GetPort(&savePort);
  232. SetPort(theD);
  233. retVal = StdFilterProc(theD, thEv, iHit);
  234. SetPort(savePort);
  235. return retVal;
  236. }
  237. */
  238. #endif
  239.  
  240.